﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Threading.Tasks;
//using Commonality.Model;

//namespace Merge.Model
//{
//    public enum ESignalType
//    {
//        SIG_X,
//        SIG_Y,
//        SIG_F,
//        SIG_G,
//        SIG_M,
//        SIG_D,
//        SIG_T,
//        SIG_NULL
//    };
//    public struct TPLCCell
//    {
//        public bool enable;         //使能;（暂时主要用于M，Y指令的使能）
//        public ESignalType sigType; //信号类型
//        public ushort stationNumber;//站号
//        public ushort addr;         //地址
//        public ushort offset;       //偏移值

//        public string instruction;  //命令名称
//    };
//    public delegate void ImplementLADEx();
//    public class CPLCControl
//    {
//        /// <summary>
//        /// 起始站号        
//        /// </summary>
//        public static int workstationFirstAddress { get; set; }
//        /// <summary>
//        /// 使用站数
//        /// </summary>
//        public static int workstationNumOffset { get; set; }
//        private static void InitPLCControl()
//        {
//            MitsubisiPlcModel.MitsubisiPlcModelIni(workstationFirstAddress,workstationNumOffset);
//            PLCTimeGenerator.InitPLCTimeGenerator();
//        }
//        public static void SetLADProcessEx(ImplementLADEx lad)
//        {
//            InitPLCControl();
//            PLCCirculation.PLCCirculationEvent += lad;
//            PLCCirculation.Start_timer();
//        }

//        public static void SetLADProcessExBranch(short num, ImplementLADEx lad)
//        {
//            switch (num)
//            {
//                case 1:
//                    PLCCirculation.PLCCirculationEventBranch1 += lad;
//                    break;
//                case 2:
//                    PLCCirculation.PLCCirculationEventBranch2 += lad;
//                    break;
//                case 3:
//                    PLCCirculation.PLCCirculationEventBranch3 += lad;
//                    break;
//                case 4:
//                    PLCCirculation.PLCCirculationEventBranch4 += lad;
//                    break;
//                case 5:
//                    PLCCirculation.PLCCirculationEventBranch5 += lad;
//                    break;
//                case 6:
//                    PLCCirculation.PLCCirculationEventBranch6 += lad;
//                    break;
//                case 7:
//                    PLCCirculation.PLCCirculationEventBranch7 += lad;
//                    break;
//                case 8:
//                    PLCCirculation.PLCCirculationEventBranch8 += lad;
//                    break;
//                case 9:
//                    PLCCirculation.PLCCirculationEventBranch9 += lad;
//                    break;
//                case 10:
//                    PLCCirculation.PLCCirculationEventBranch10 += lad;
//                    break;
//                default:
//                    break;
//            }
//        }

//        public static string OpenPLC(ushort StationNumber)
//        {
//            return MitsubisiPlcModel.Open(StationNumber);
//        }
//        public static void ClosePLC(ushort StationNumber)
//        {
//            MitsubisiPlcModel.Close(StationNumber);
//        }
//        public static void InitPlcCell(out TPLCCell cell, ESignalType type,ushort stationNumber, ushort address, ushort offset)
//        {
//            cell.enable = true;
//            cell.sigType = type;
//            cell.stationNumber = stationNumber;
//            cell.addr = address;
//            cell.offset = offset;

//            cell.instruction = type.ToString() + stationNumber + address + offset;
//        }
//        public static void InitPlcCell(out TPLCCell cell, ESignalType type, ushort address, ushort offset)
//        {
//            cell.enable = true;
//            cell.sigType = type;
//            cell.stationNumber = 0;
//            cell.addr = address;
//            cell.offset = offset;

//            cell.instruction = type.ToString() + address + offset;
//        }
//        public static void LAD_SetCell(TPLCCell cell)
//        {
//            #region 寄存器
//            if (cell.instruction == "SIG_M" + cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "M" + cell.offset;
//                MitsubisiPlcModel.WriteBit(cell.stationNumber, device, 1);              
//            }
//            #endregion
//            #region 通用输出
//            if (cell.instruction == "SIG_Y" + cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "Y" + cell.addr + cell.offset;
//                switch (cell.offset)
//                {
//                    case 10:
//                        device = "Y" + cell.addr + "A";
//                        break;
//                    case 11:
//                        device = "Y" + cell.addr + "B";
//                        break;
//                    case 12:
//                        device = "Y" + cell.addr + "C";
//                        break;
//                    case 13:
//                        device = "Y" + cell.addr + "D";
//                        break;
//                    case 14:
//                        device = "Y" + cell.addr + "E";
//                        break;
//                    case 15:
//                        device = "Y" + cell.addr + "F";
//                        break;
//                    default:
//                        break;
//                }
//                MitsubisiPlcModel.WriteBit(cell.stationNumber, device, 1);
//            }
//            #endregion

//        }
//        public static void LAD_ResetCell(TPLCCell cell)
//        {
//            #region 寄存器
//            if (cell.instruction == "SIG_M" + cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "M" + cell.offset;
//                MitsubisiPlcModel.WriteBit(cell.stationNumber, device, 0);
//            }
//            #endregion
//            #region 通用输出
//            if (cell.instruction == "SIG_Y" + cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "Y" + cell.addr + cell.offset;
//                MitsubisiPlcModel.WriteBit(cell.stationNumber, device, 0);
//            }
//            #endregion
//            #region 定时器
//            if (cell.instruction == "SIG_T" + cell.addr + cell.offset)
//            {
//                PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].enable = false;
//                PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].PLC_Time = 0;
//                PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].PLC_Time_Goal = 0;
//                PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].PLC_Over = false;
//            }
//            #endregion
//        }
//        public static byte LAD_CheckCell(TPLCCell cell)
//        {
//            #region 通用输入
//            if (cell.instruction == "SIG_X" + cell.addr + cell.offset)
//            {
//                string device = "X" + cell.addr + cell.offset;
//                return MitsubisiPlcModel.ReadBit(cell.stationNumber, device);
//            }
//            #endregion
//            #region 通用输出
//            if (cell.instruction == "SIG_Y" + cell.addr + cell.offset)
//            {
//                string device = "Y" + cell.addr + cell.offset;
//                return MitsubisiPlcModel.ReadBit(cell.stationNumber, device);
//            }
//            #endregion
//            #region 寄存器
//            if (cell.instruction == "SIG_M" + cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "M" + cell.offset;
//                return MitsubisiPlcModel.ReadBit(cell.stationNumber, device);
//            }
//            #endregion
//            #region 定时器
//            if (cell.instruction == "SIG_T" + cell.addr + cell.offset)
//            {
//                if (PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].PLC_Over)
//                {
//                    return 1;
//                }
//                else
//                {
//                    return 0;
//                }
//            }
//            #endregion
//            return 0;
//        }
//        public static void LAD_SetDblCell(TPLCCell cell, short data)
//        {
//            #region 寄存器
//            if (cell.instruction == "SIG_D"+ cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "D" + cell.offset;
//                MitsubisiPlcModel.WriteBytes(cell.stationNumber, device,data);
//            }
//            #endregion
//        }
//        public static short LAD_GetDblCell(TPLCCell cell)
//        {
//            #region 寄存器
//            if (cell.instruction == "SIG_D" + cell.stationNumber + cell.addr + cell.offset)
//            {
//                string device = "D" + cell.offset;
//                return MitsubisiPlcModel.ReadBytes(cell.stationNumber, device);
//            }

//            #endregion
//            return 0;
//        }
//        public static byte LAD_SetTCell(TPLCCell cell, uint nElapse)
//        {
//            if (cell.instruction == "SIG_T" + cell.addr + cell.offset)
//            {
//                PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].enable = true;               //定时器使能
//                PLCTimeGenerator.PLC_T_Memory[cell.addr, cell.offset].PLC_Time_Goal = nElapse;     //计数周期
//            }
//            return 0;
//        }





//        //public static int data1_;
//        //public static int data2_;
//        //public static int data3_;
//        //public static int data4_;
//        //public static int data5_;
//        //public static int data6_;
//    }

//    class PLCTimeGenerator
//    {

//        /// <summary>
//        /// 计数单元结构
//        /// </summary>
//        public struct PLC_T
//        {
//            /// <summary>
//            /// 计数器
//            /// </summary>
//            public uint PLC_Time;
//            /// <summary>
//            /// 计数器使能
//            /// </summary>
//            public bool enable;
//            /// <summary>
//            /// 定时时间
//            /// </summary>
//            public uint PLC_Time_Goal;
//            /// <summary>
//            /// 定时时间到时标志
//            /// </summary>
//            public bool PLC_Over;
//        }

//        /// <summary>
//        /// 内部计数器
//        /// </summary>
//        public static PLC_T[,] PLC_T_Memory = new PLC_T[8, 16];


//        private static System.Threading.Timer PLCthreadTimer;//一定要声明成局部变量以保持对Timer的引用，否则会被垃圾收集器回收
//        public static void InitPLCTimeGenerator()
//        {
//            #region 初始化计数器资源
//            for (int i = 0; i < 8; i++)                 //初始化
//            {
//                for (int j = 0; j < 16; j++)
//                {
//                    PLC_T_Memory[i, j].enable = false;
//                    PLC_T_Memory[i, j].PLC_Time = 0;
//                    PLC_T_Memory[i, j].PLC_Time_Goal = 0;
//                    PLC_T_Memory[i, j].PLC_Over = false;
//                }
//            }
//            #endregion
//            #region 启动定时器
//            Start_timer();
//            #endregion
//        }
//        private static void Start_timer()
//        {
//            PLCthreadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(PLC_Timer_Tick), null, 0, 1);
//            //A表示要执行的方法,可以带参数也可以不带参数;B表示要给这A方法传递的参数，如果A方法不带参数，B可以为空
//            //C表示这个方法调用之前等待的时间 ;D表示这个方法多久调用一次
//            //dueTime：调用 callback 之前延迟的时间量（以毫秒为单位）。指定 Timeout.Infinite 以防止计时器开始计时。指定零 (0) 以立即启动计时器。
//            //即过多长时间启动定时器，为-1则防止启动定时器
//            //Period：调用 callback 的时间间隔（以毫秒为单位）。指定 Timeout.Infinite 可以禁用定期终止。
//            //如果period为0或-1，dueTime大于0，则callback只执行一次
//        }
//        public static void Stop_timer()
//        {
//            if (PLCthreadTimer != null)
//                PLCthreadTimer.Change(-1, -1);
//            if (PLCthreadTimer != null)
//                PLCthreadTimer.Dispose();//当不再需要定时器时，请用Dispose释放
//        }
//        private static void PLC_Timer_Tick(Object state)
//        {
//            //设置8*16个定时器供回调函数中使用
//            for (int i = 0; i < 8; i++)
//            {
//                for (int j = 0; j < 16; j++)
//                {
//                    if (PLC_T_Memory[i, j].enable == true
//                        && PLC_T_Memory[i, j].PLC_Time_Goal != 0
//                        && PLC_T_Memory[i, j].PLC_Time != PLC_T_Memory[i, j].PLC_Time_Goal
//                        && PLC_T_Memory[i, j].PLC_Over == false)                                //计时器使能-开始计数
//                    {
//                        PLC_T_Memory[i, j].PLC_Time++;                  //计数
//                    }
//                    else if (PLC_T_Memory[i, j].enable == true
//                        && PLC_T_Memory[i, j].PLC_Time_Goal != 0
//                        && PLC_T_Memory[i, j].PLC_Time == PLC_T_Memory[i, j].PLC_Time_Goal
//                        && PLC_T_Memory[i, j].PLC_Over == false)                               //计数器计数到时-置位输出
//                    {
//                        PLC_T_Memory[i, j].PLC_Over = true;            //输出标志
//                        PLC_T_Memory[i, j].PLC_Time = 0;
//                    }
//                }
//            }
//        }
//    }
//    class PLCCirculation
//    {
//        public static event ImplementLADEx PLCCirculationEvent;

//        public static event ImplementLADEx PLCCirculationEventBranch1;
//        public static event ImplementLADEx PLCCirculationEventBranch2;
//        public static event ImplementLADEx PLCCirculationEventBranch3;
//        public static event ImplementLADEx PLCCirculationEventBranch4;
//        public static event ImplementLADEx PLCCirculationEventBranch5;
//        public static event ImplementLADEx PLCCirculationEventBranch6;
//        public static event ImplementLADEx PLCCirculationEventBranch7;
//        public static event ImplementLADEx PLCCirculationEventBranch8;
//        public static event ImplementLADEx PLCCirculationEventBranch9;
//        public static event ImplementLADEx PLCCirculationEventBranch10;


//        private static bool ScanComplement = true;
//        private static bool ScanComplementBranch1 = true;
//        private static bool ScanComplementBranch2 = true;
//        private static bool ScanComplementBranch3 = true;
//        private static bool ScanComplementBranch4 = true;
//        private static bool ScanComplementBranch5 = true;
//        private static bool ScanComplementBranch6 = true;
//        private static bool ScanComplementBranch7 = true;
//        private static bool ScanComplementBranch8 = true;
//        private static bool ScanComplementBranch9 = true;
//        private static bool ScanComplementBranch10 = true;




//        private static int ScanTime = 200;

//        private static System.Threading.Timer threadTimer;//一定要声明成局部变量以保持对Timer的引用，否则会被垃圾收集器回收

//        public static void Start_timer()
//        {
//            threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(Thread_Timer_Tick), null, 0, ScanTime);


//            //A表示要执行的方法,可以带参数也可以不带参数;B表示要给这A方法传递的参数，如果A方法不带参数，B可以为空
//            //C表示这个方法调用之前等待的时间 ;D表示这个方法多久调用一次
//            //dueTime：调用 callback 之前延迟的时间量（以毫秒为单位）。指定 Timeout.Infinite 以防止计时器开始计时。指定零 (0) 以立即启动计时器。
//            //即过多长时间启动定时器，为-1则防止启动定时器
//            //Period：调用 callback 的时间间隔（以毫秒为单位）。指定 Timeout.Infinite 可以禁用定期终止。
//            //如果period为0或-1，dueTime大于0，则callback只执行一次

//        }
//        public static void Stop_timer()
//        {
//            if (threadTimer != null)
//                threadTimer.Change(-1, -1);
//            if (threadTimer != null)
//                threadTimer.Dispose();//当不再需要定时器时，请用Dispose释放
//        }
//        private static void Thread_Timer_Tick(Object state)
//        {
//            //             if (!b_communication_success)//查看有没有通信成功
//            //                 return;
//            if (!ScanComplement)//如果定时器没有执行完成，则继续执行
//                return;
//            ScanComplement = false;
//            #region 输入扫描
//            ReadMotionCardParameter();
//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegate();
//            ///回原点
//            HomeInvolution();
//            #endregion
//            #region 输出刷新
//            WriteMotionCardParameter();

//            #endregion
//            ScanComplement = true;
//        }


//        private static void PLCCirculationDelegate()
//        {
//            if (PLCCirculationEvent != null)
//            {
//                PLCCirculationEvent();
//            }
//        }

//        private static void HomeInvolution()
//        {

//        }
//        private static void ReadMotionCardParameter()
//        {
//            //CPLCControl.data1_ = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[3].ReadDeviceRandom("D801", 20, out CPLCControl.data1_);
//            //CPLCControl.data1_ = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[4].ReadDeviceRandom("D801", 20, out CPLCControl.data2_);
//            //CPLCControl.data1_ = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[5].ReadDeviceRandom("D801", 20, out CPLCControl.data3_);
//            //CPLCControl.data1_ = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[6].ReadDeviceRandom("D801", 20, out CPLCControl.data4_);
//            //CPLCControl.data1_ = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[7].ReadDeviceRandom("D801", 20, out CPLCControl.data5_);
//            //CPLCControl.data1_ = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[8].ReadDeviceRandom("D801", 20, out CPLCControl.data6_);
//        }

//        private static void WriteMotionCardParameter()
//        {
//            //int data1 = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[3].WriteDeviceRandom("D801", 20, ref data1);
//            //int data2 = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[4].WriteDeviceRandom("D801", 20, ref data2);
//            //int data3 = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[5].WriteDeviceRandom("D801", 20, ref data3);
//            //int data4 = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[6].WriteDeviceRandom("D801", 20, ref data4);
//            //int data5 = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[7].WriteDeviceRandom("D801", 20, ref data5);
//            //int data6 = 0x00;
//            //MitsubisiPlcModel.MitsubisiPLC[8].WriteDeviceRandom("D801", 20, ref data6);
//        }
//        #region 支线任务
//        //支线1
//        private static void Thread_Timer_TickBranch1(Object state)
//        {
//            if (!ScanComplementBranch1)
//                return;
//            ScanComplementBranch1 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch1();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch1 = true;
//        }
//        private static void PLCCirculationDelegateBranch1()
//        {
//            if (PLCCirculationEventBranch1 != null)
//            {
//                PLCCirculationEventBranch1();
//            }
//        }
//        //支线2
//        private static void Thread_Timer_TickBranch2(Object state)
//        {
//            if (!ScanComplementBranch2)
//                return;
//            ScanComplementBranch2 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch2();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch2 = true;
//        }
//        private static void PLCCirculationDelegateBranch2()
//        {
//            if (PLCCirculationEventBranch2 != null)
//            {
//                PLCCirculationEventBranch2();
//            }
//        }
//        //支线3
//        private static void Thread_Timer_TickBranch3(Object state)
//        {
//            if (!ScanComplementBranch3)
//                return;
//            ScanComplementBranch3 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch3();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch3 = true;
//        }
//        private static void PLCCirculationDelegateBranch3()
//        {
//            if (PLCCirculationEventBranch3 != null)
//            {
//                PLCCirculationEventBranch3();
//            }
//        }
//        //支线4
//        private static void Thread_Timer_TickBranch4(Object state)
//        {
//            if (!ScanComplementBranch4)
//                return;
//            ScanComplementBranch4 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch4();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch4 = true;
//        }
//        private static void PLCCirculationDelegateBranch4()
//        {
//            if (PLCCirculationEventBranch4 != null)
//            {
//                PLCCirculationEventBranch4();
//            }
//        }
//        //支线5
//        private static void Thread_Timer_TickBranch5(Object state)
//        {
//            if (!ScanComplementBranch5)
//                return;
//            ScanComplementBranch5 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch5();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch5 = true;
//        }
//        private static void PLCCirculationDelegateBranch5()
//        {
//            if (PLCCirculationEventBranch5 != null)
//            {
//                PLCCirculationEventBranch5();
//            }
//        }
//        //支线6
//        private static void Thread_Timer_TickBranch6(Object state)
//        {
//            if (!ScanComplementBranch6)
//                return;
//            ScanComplementBranch6 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch6();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch6 = true;
//        }
//        private static void PLCCirculationDelegateBranch6()
//        {
//            if (PLCCirculationEventBranch6 != null)
//            {
//                PLCCirculationEventBranch6();
//            }
//        }
//        //支线7
//        private static void Thread_Timer_TickBranch7(Object state)
//        {
//            if (!ScanComplementBranch7)
//                return;
//            ScanComplementBranch7 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch7();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch7 = true;
//        }
//        private static void PLCCirculationDelegateBranch7()
//        {
//            if (PLCCirculationEventBranch7 != null)
//            {
//                PLCCirculationEventBranch7();
//            }
//        }
//        //支线8
//        private static void Thread_Timer_TickBranch8(Object state)
//        {
//            if (!ScanComplementBranch8)
//                return;
//            ScanComplementBranch8 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch8();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch8 = true;
//        }
//        private static void PLCCirculationDelegateBranch8()
//        {
//            if (PLCCirculationEventBranch8 != null)
//            {
//                PLCCirculationEventBranch8();
//            }
//        }
//        //支线9
//        private static void Thread_Timer_TickBranch9(Object state)
//        {
//            if (!ScanComplementBranch9)
//                return;
//            ScanComplementBranch9 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch9();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch9 = true;
//        }
//        private static void PLCCirculationDelegateBranch9()
//        {
//            if (PLCCirculationEventBranch9 != null)
//            {
//                PLCCirculationEventBranch9();
//            }
//        }
//        //支线10
//        private static void Thread_Timer_TickBranch10(Object state)
//        {
//            if (!ScanComplementBranch10)
//                return;
//            ScanComplementBranch10 = false;
//            #region 输入扫描

//            #endregion
//            #region 逻辑计算
//            ///回调逻辑计算
//            PLCCirculationDelegateBranch10();
//            #endregion
//            #region 输出刷新


//            #endregion
//            ScanComplementBranch10 = true;
//        }
//        private static void PLCCirculationDelegateBranch10()
//        {
//            if (PLCCirculationEventBranch10 != null)
//            {
//                PLCCirculationEventBranch10();
//            }
//        }
//        #endregion
//    }
//}
